package com.cma.common.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Map;
import java.util.Set;

public  class RedisService {
	
	//操作redis客户端
    public static Jedis jedis;
    @Autowired
    public JedisConnectionFactory jedisConnectionFactory;
    
	/**
     * 通过key删除（字节）
     * @param key
     */
    public void del(byte [] key){
        this.getJedis().del(key);
        
    }
    /**
     * 通过key删除
     * @param key
     */
    public void del(String key){
        this.getJedis().del(key);
    }
    
    /** 
    * @Title: oset 
    * @Description: TODO(缓存对象) 
    * @param @param key
    * @param @param obj    需要缓存的对象
    * @return void    返回类型 
    * @throws 
    */
    public <T> void oset(String key,T obj)
    {
    	this.getJedis().set(key.getBytes(), ObjectsTranscoder.serialize(obj));
    }
    /** 
    * @Title: oset 
    * @Description: TODO(存储对象，设置缓存过期时间) 
    * @param @param key
    * @param @param obj 缓存对象
    * @param @param liveTime    缓存过期时间 
    * @return void    返回类型 
    * @throws 
    */
    public <T> void oset(String key,T obj,int liveTime)
    {
    	this.set(key.getBytes(), ObjectsTranscoder.serialize(obj));
    	this.getJedis().expire(key.getBytes(), liveTime);
    }
    /** 
    * @Title: oget 
    * @Description: TODO(读取缓存对象) 
    * @param @param key
    * @param @return    设定文件 
    * @return Object    返回类型 
    * @throws 
    */
    public Object oget(String key)
    {
    	byte[] bytes = null;
    	try
    	{
    		bytes = this.getJedis().get(key.getBytes());
    	}
    	catch(Exception e)
    	{
    		
    	}
    	if(bytes == null)
    		return null;
    	return ObjectsTranscoder.unserialize(bytes);
    }
    /**
     * 缓存字符串类型， 并且设置存活时间(byte)
     * @param key 缓存key
     * @param value byte[]数组 
     * @param liveTime 缓存过期时长
     */
    public void set(byte [] key,byte [] value,int liveTime){
        this.set(key, value);
        this.getJedis().expire(key, liveTime);
    }
    
    /** 
    * @Title: hmset 
    * @Description: TODO(缓存Map对象) 
    * @param @param key  缓存key
    * @param @param hash    缓存的Map对象
    * @return void    返回类型 
    * @throws 
    */
    public void hmset(String key,Map<String, String> hash)
    {
    	this.getJedis().hmset(key, hash);
    }
    /** 
    * @Title: hmset 
    * @Description: TODO(缓存Map对象,并设置过期时长) 
    * @param @param key 缓存key
    * @param @param hash 缓存的Map对象
    * @param @param liveTime    缓存过期时长 
    * @return void    返回类型 
    * @throws 
    */
    public void hmset(String key,Map<String, String> hash,int liveTime)
    {
    	this.hmset(key, hash);
    	this.getJedis().expire(key, liveTime);
    }
    /** 
    * @Title: hmget 
    * @Description: TODO(通过key,获取缓存的Map) 
    * @param @param key
    * @param @return    设定文件 
    * @return Map<String,String>    返回类型 
    * @throws 
    */
    public Map<String, String> hmget(String key)
    {
    	return this.getJedis().hgetAll(key);
    }
    /** 
    * @Title: hmget 
    * @Description: TODO(key定位Map,返回keys对应的value数组) 
    * @param @param key
    * @param @param keys 
    * @param @return    设定文件 
    * @return List<String>    返回类型 
    * @throws 
    */
    public List<String> hmget(String key,String[] keys)
    {
    	return this.getJedis().hmget(key, keys);
    }
    /**
     * @param <T> 
    * @Title: lpush 
    * @Description: TODO(缓存List数组) 
    * @param @param key
    * @param @param list
    * @param @throws IOException    设定文件 
    * @return void    返回类型 
    * @throws 
    */
    public <T> void lpush(String key,T list)
    {
    	this.oset(key, list);
    }
    /** 
    * @Title: lpush 
    * @Description: TODO(缓存List数组，并设置过期时长)  
    * @param @param key
    * @param @param list
    * @param @param liveTime 过期时长
    * @param @throws IOException    设定文件 
    * @return void    返回类型 
    * @throws 
    */
    public void lpush(String key,List<?> list,int liveTime)
    {
    	this.lpush(key,  list);
    	this.getJedis().expire(key.getBytes(), liveTime);
    }
    /** 
    * @Title: lpop 
    * @Description: TODO(通过key,获取缓存的List数组) 
    * @param @param key
    * @param @return
    * @param @throws ClassNotFoundException
    * @param @throws IOException    设定文件 
    * @return List<?>    返回类型 
    * @throws 
    */
    public Object lpop(String key)
    {
    	return this.oget(key);
    }
    
    /** 
    * @Title: set 
    * @Description: TODO(缓存字符串，并设置过期时长) 
    * @param @param key  关键字
    * @param @param value 缓存的字符串
    * @param @param liveTime   缓存过期时长 
    * @return void    返回类型 
    * @throws 
    */
    public void set(String key,String value,int liveTime){
        this.set(key, value);
        this.getJedis().expire(key, liveTime);
    }
    
    /** 
    * @Title: set 
    * @Description: TODO(缓存字符串) 
    * @param @param key 关键字
    * @param @param value    缓存的字符串 
    * @return void    返回类型 
    * @throws 
    */
    public void set(String key,String value){
        this.getJedis().set(key, value);
    }
    /**添加key value (字节)(序列化)
     * @param key
     * @param value
     */
    public void set(byte [] key,byte [] value){
        this.getJedis().set(key, value);
    }
    /**
     * 获取redis value (String)
     * @param key
     * @return
     */
    public String get(String key){
       	return this.getJedis().get(key);
    }
    /**
     * 获取redis value (byte [] )(反序列化)
     * @param key
     * @return
     */
    public byte[] get(byte [] key){
        return this.getJedis().get(key);
    }

    /**
     * 通过正则匹配keys
     * @param pattern
     * @return
     */
    public Set<String> keys(String pattern){
        return this.getJedis().keys(pattern);
    }

    /**
     * 检查key是否已经存在
     * @param key
     * @return
     */
    public boolean exists(String key){
        return this.getJedis().exists(key);
    }
    /**
     * 清空redis 所有数据
     * @return
     */
    public String flushDB(){
        return this.getJedis().flushDB();
    }
    /**
     * 查看redis里有多少数据
     */
    public long dbSize(){
        return this.getJedis().dbSize();
    }
    /**
     * 检查是否连接成功
     * @return
     */
    public String ping(){
        return this.getJedis().ping();
    }
    /**
     * 获取一个jedis 客户端
     * @return
     */
    public Jedis getJedis(){
        if(jedis == null){
            return jedisConnectionFactory.getShardInfo().createResource();
        }
        return jedis;
    }
    public RedisService (){

    }
}
